#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>

class Task
{
public:
    Task(int a, int b) : _a(a), _b(b){}

    int Work()
    {
        return _a + _b;
    }

    ~Task(){}
private:
    int _a;
    int _b;
};

class Result
{
public:
    Result(int result) : _result(result){}

    int GetResult()
    {
        return _result;
    }

    Result(){}
private:
    int _result;
};

void* thread_function(void* args)
{
    Task* pt = (Task*)args;
    sleep(1);
    Result* res = new Result(pt->Work());
    sleep(100);
    pthread_exit(res);
    //线程的终止问题：
    //1、只要执行到return，就是线程终止
    //  线程不能用exit终止，因为exit是用来终止进程的，导致所有线程全部退出
    //2、使用pthread_exit和return是一样的效果
    //3、但常用的是主线程取消新线程pthread_cancle（要保证新线程已经被启动）
    std::cout << "haah" << std::endl;
}

//主线程如果不再想关注子线程，就需要将子线程设置为分离状态（！joinable or detach）
//子线程默认是需要被等待的，即joinable
//理解：线程分离，主分离新，新把自己分离，但是即使线程被分离，依旧在进程的地址空间里
//被分离的线程依然可以访问操作主进程的地址空间，只是主进程不等待新线程

int main()
{
    pthread_t tid;

    Task* t = new Task(10, 20);

    //给线程传参数可以是任意类型，线程入口函数的返回值也可以是任意类型
    pthread_create(&tid, nullptr, thread_function, t);
    sleep(3);
    std::cout << "我要杀死子线程了" << std::endl;
    pthread_cancel(tid);

    void* ret = nullptr;
    pthread_join(tid, &ret);
    std::cout << "子线程结束，结果是：" << (long long)ret << std::endl;
    //这里返回值是-1,及PTHREAD_CANCELD信号

    //Result* res = nullptr;
    // pthread_join(tid, (void**)&res);使用pthread_join默认线程无异常
    // int n = res->GetResult();
    // std::cout << "子线程结束:" << n << std::endl;
    return 0;
}